'''
Python 列表的操作

1. 创建一个列表`list1`，其包含元素 1, 2, 3, 4, 5。

2. 向`list1` 添加一个元素 6。

3. 从`list1` 中删除元素 3。

4. 修改`list1` 中的第二个元素值为 8。

5. 找出`list1` 中值为 8 的元素索引。

6. 遍历`list1`，打印每个元素的值。

7. 利用循环，将一个新列表 `7, 8, 9]` 的每个元素添加到`list1` 的末尾。

8. 使用一个命令，将列表 `10, 11, 12]` 添加到`list1` 的末尾。

9. 使用切片操作，获取`list1` 第三个元素到第五个元素（包含第五个元素）。

10. 将`list1` 的第三个元素修改为两个新元素 `13, 14]`（不是列表中的一个列表，而是将两个新元素插入到指定位置）。

'''
#1. 创建一个列表`list1`，其包含元素 1, 2, 3, 4, 5。
import random

list1=[1,2,3,4,5]
# 2. 向`list1` 添加一个元素 6。
list1.append(6)
#3. 从`list1` 中删除元素 3。
list1.remove(3)
# 4. 修改`list1` 中的第二个元素值为 8。
list1[1]=8
# 5. 找出`list1` 中值为 8 的元素索引。
print(list1.index(8))
# 6. 遍历`list1`，打印每个元素的值。
for i in list1:
    print(i,end="\t")
# 7. 利用循环，将一个新列表 `7, 8, 9]` 的每个元素添加到`list1` 的末尾。
list1.extend([7,8,9])
# 8. 使用一个命令，将列表 `10, 11, 12]` 添加到`list1` 的末尾。
list1.extend([10,11,12])
# 9. 使用切片操作，获取`list1` 第三个元素到第五个元素（包含第五个元素）。
print(list1[2:6])
# 10. 将`list1` 的第三个元素修改为两个新元素 `13, 14]`（不是列表中的一个列表，而是将两个新元素插入到指定位置）。
list1.insert(3,14)
list1.insert(3,13)
print(list1)
print("------------------------------------------\n")
'''
给定初始列表`my_list = [3, "apple", 9, "banana", 7, "cherry", 2, "date", 5, "elderberry"]`，执行以下操作：

1. 向my_list中添加一个元素"fig"。
2. 从my_list中删除元素"banana"。
3. 将元素7修改为字符串"grape"。
4. 查找并打印元素"cherry"的索引值。
5. 遍历my_list并打印每个元素。
6. 在"cherry"后面插入新元素"kiwi"。
7. 使用索引查找并打印第三个元素。
8. 使用负数索引找到并打印倒数第二个元素。
9. 使用切片操作获取第三个至第七个元素并打印结果。
10. 使用切片操作反转整个列表并打印结果。
11. 对列表中的字符串进行排序，并保留数字在原位。
12. 将my_list中的数字替换为它们对应的字符串形式（如1->'one'），不改变列表中原有的
'''
my_list = [3, "apple", 9, "banana", 7, "cherry", 2, "date", 5, "elderberry"]
#1. 向my_list中添加一个元素"fig"。
my_list.append("fig")
#2. 从my_list中删除元素"banana"。
my_list.remove("banana")
#3. 将元素7修改为字符串"grape"。
my_list[my_list.index(7)]="grape"
#4. 查找并打印元素"cherry"的索引值。
print(my_list.index("cherry"))
#5. 遍历my_list并打印每个元素。
for i in my_list:
    print(i,end="\t")
# 6. 在"cherry"后面插入新元素"kiwi"。
my_list.insert(my_list.index("cherry")+1,"kiwi")
# 7. 使用索引查找并打印第三个元素。
print(my_list[2])
# 8. 使用负数索引找到并打印倒数第二个元素。
print(my_list[-2])
# 9. 使用切片操作获取第三个至第七个元素并打印结果。
print(my_list[2:7])
# 10. 使用切片操作反转整个列表并打印结果。
print(my_list[::-1])
# 11. 对列表中的字符串进行排序，并保留数字在原位。
print("--------------------------------")
print(my_list)
for i in range(len(my_list)):
    if isinstance(my_list[i], int):
            continue
    for j in range(i+1,len(my_list)):
        if isinstance(my_list[j], int):
            continue
        if my_list[i]>my_list[j]:
            temp=my_list[i]
            my_list[i]=my_list[j]
            my_list[j]=temp
# 12. 将my_list中的数字替换为它们对应的字符串形式（如1->'one'），不改变列表中原有的字符串形式）
dict={"1":"one","2":"two","3":"three","4":"four","5":"five","6":"six","7":"seven","8":"eight","9":"nine","10":"ten"}
for i in range(len(my_list)):
    if isinstance(my_list[i], int):
        my_list[i]= dict[str(my_list[i])]
print(my_list)

'''
1. 创建一个列表包含从1到100的所有偶数。
2. 将上述列表中所有偶数替换为它们的平方。
3. 从上述列表中删除所有大于1000的数字。
4. 将列表逆序。
5. 使用切片操作取出列表中的前10个元素。
6. 将一个新列表`[101, 102, 103]`加到现有列表的末尾。
7. 计算列表中元素的平均值。
8. 找到列表中的最大值和最小值。
9. 找出列表中第一次出现的11的索引位置。
10. 用循环遍历列表，把每个数字替换为其对应的字符形式（例如：1替换为'1'）。注意使用不同类型的循环来实现。
11. 将列表中的所有元素转换成浮点数形式。
12. 找出列表中所有大于50的元素个数。
13. 在列表的第3个位置插入数字99。
14. 删除列表中的最后一个元素。
15. 使用列表推导式创建一个新列表，包含原列表中每个数字乘以2的结果。
16. 将列表分成两部分，一部分是小于等于50的数，另一部分是大于50的数。
17. 将列表转换为一个字典，其中列表元素作为键，其在列表中的索引作为值。
18. 使用`enumerate`函数遍历列表，并打印元素及其索引。
19. 从列表中随机取出一个元素。
20. 将列表保存到一个txt文件里，每个元素占一行。
'''
print("-------------------")
#1. 创建一个列表包含从1到100的所有偶数。
list2=[i for i in range(2,101,2)]
#2. 将上述列表中所有偶数替换为它们的平方。
for i in range(len(list2)):
    list2[i]=list2[i]**2
#3. 从上述列表中删除所有大于1000的数字。
list2=[i for i in list2 if i<=1000]
#4. 将列表逆序。
list2.reverse()
#5. 使用切片操作取出列表中的前10个元素。
list2=list2[:10]
#6. 将一个新列表`[101, 102, 103]`加到现有列表的末尾。
list2.extend([101,102,103])
#7. 计算列表中元素的平均值。
print(sum(list2)/len(list2))
#8. 找到列表中的最大值和最小值。
print(max(list2),min(list2))
#9. 找出列表中第一次出现的11的索引位置。
try:
    print(list2.index(11))
except ValueError:
    print("11 not in list2")
#10. 用循环遍历列表，把每个数字替换为其对应的字符形式（例如：1替换为'1'）。
for i in range(len(list2)):
    list2[i]=str(list2[i])
#11. 将列表中的所有元素转换成浮点数形式。
list2=[float(i) for i in list2]
#12. 找出列表中所有大于50的元素个数。
print(len([i for i in list2 if i>50]))
#13. 在列表的第3个位置插入数字99。
list2.insert(2,99)
#14. 删除列表中的最后一个元素。
list2.pop()
#15. 使用列表推导式创建一个新列表，包含原列表中每个数字乘以2的结果。
list2=[i*2 for i in list2]
#16. 将列表分成两部分，一部分是小于等于50的数，另一部分是大于50的数。
list3=[i for i in list2 if i<=50]
list4=[i for i in list2 if i>50]
list2=[list3,list4]
#17. 将列表转换为一个字典，其中列表元素作为键，其在列表中的索引作为值。
dict2={}
list2=[i for i in range(2,101,2)]
for i in range(len(list2)):
    dict2[list2[i]]=i
print("--------------18----------------------------\n")
#18. 使用`enumerate`函数遍历列表，并打印元素及其索引。
for index,j in enumerate(list2):
    print(j,index)
#19. 从列表中随机取出一个元素。
print(random.choice(list2))
#20. 将列表保存到一个txt文件里，每个元素占一行。
with open("list2.txt","w") as file:
    for i in list2:
        file.write(str(i)+"\n")

print("--------------字典----------------\n")
'''
假设有一个字典`person_info` 储存了一个人的信息，包含不少于5个键值对，如下所示：
person_info = {
    "name": "Alex",
    "age": 30,
    "country": "USA",
    "language": ["English", "Spanish"],
    "is_student": False
}

1.打印`person_info` 字典的`name` 值。
2.. 修改`age` 的值为 31。
3.向字典中添加一个新的键值对 `height": 175`。
4.删除字典中的 `is_student"` 键及其值。
5.使用循环遍历字典，打印所有的键和值。
6.检查字典中是否有 `email"` 这个键，如果没有，添加 `email": "alex@example.com"`。
7.将`language` 的值改为只包含 `English"`。
8.获取并打印字典中`language` 列表的长度。
9.向`language` 列表中添加一种新语言 `French"`。
 循环插入新的键值对到字典：将 ` hobby'` + 数字 作为键，相应的 ` hobby'` + 数字值 作为值，数字从1至3。
'''

person_info = {
    "name": "Alex",
    "age": 30,
    "country": "USA",
    "language": ["English", "Spanish"],
    "is_student": False
}
#1.打印`person_info` 字典的`name` 值。
print(person_info["name"])
#2.. 修改`age` 的值为 31。
person_info["age"]=31
#3.向字典中添加一个新的键值对 `height": 175`。
person_info["height"]=175
#4.删除字典中的 `is_student"` 键及其值。
del person_info["is_student"]
#5.使用循环遍历字典，打印所有的键和值。
for i in person_info:
    print(i,person_info[i])
#6.检查字典中是否有 `email"` 这个键，如果没有，添加 `email": "alex@example.com"`。
person_info.update({"email":"alex@example.com"})
#7.将`language` 的值改为只包含 `English"`。
person_info["language"]=["English"]
#8.获取并打印字典中`language` 列表的长度
print(len(person_info["language"]))
#9.向`language` 列表中添加一种新语言 `French"`。
person_info["language"].append("French")
#循环插入新的键值对到字典：将 ` hobby'` + 数字 作为键，相应的 ` hobby'` + 数字值 作为值，数字从1至3。
for i in range(1,4):
    person_info["hobby"+str(i)]="hobby"+str(i)
print(person_info)

'''
1. 新增一个员工的信息到`employees`字典中。
2. 删除一个指定的员工的信息。
3. 更新员工101的年龄至31。
4. 增加员工101薪资历史中的最新薪资至95000。
5. 计算员工101的平均薪资。
6. 找出所有年龄大于25岁的员工的姓名和ID。
7. 对`employees`中的每个员工，添加'bonus'键至其字典中，其中值是最新薪资的10%。
8. 将员工101的职位更新为"Senior Data Scientist"。
9. 从员工的信息中移除`gender`键。
10. 创建一个新的嵌套字典，该字典仅包含员工的`name`和`position`。
'''
employees = {
    101: {
        "name": "Alice",
        "age": 30,
        "gender": "Female",
        "position": "Data Scientist",
        "team": "Research",
        "salary_history": [70000, 80000, 90000]
    },
    # 更多员工数据...
}
#1. 新增一个员工的信息到`employees`字典中。
employees[102]={
    "name":"Bob",
    "age":25,
    "gender":"Male",
    "position":"Data Engineer",
    "team":"Research",
    "salary_history":[60000,70000]
}
#2. 删除一个指定的员工的信息。
del employees[102]
#3. 更新员工101的年龄至31。
employees[101]["age"]=31
#4. 增加员工101薪资历史中的最新薪资至95000。
employees[101]["salary_history"].append(95000)
#5. 计算员工101的平均薪资。
avg_salary=sum(employees[101]["salary_history"])/len(employees[101]["salary_history"])
print(avg_salary)
#6. 找出所有年龄大于25岁的员工的姓名和ID。
for i in employees:
    if employees[i]["age"]>25:
        print(employees[i]["name"],i)
#7. 对`employees`中的每个员工，添加'bonus'键至其字典中，其中值是最新薪资的10%。
for i in employees:
    employees[i]["bonus"]=employees[i]["salary_history"][-1]*0.1
#8. 将员工101的职位更新为"Senior Data Scientist"。
employees[101]["position"]="Senior Data Scientist"
#9. 从员工的信息中移除`gender`键。
for i in employees:
    del employees[i]["gender"]
#10. 创建一个新的嵌套字典，该字典仅包含员工的`name`和`position`。
new_dict={}
for i in employees:
    new_dict[i]={"name":employees[i]["name"],"position":employees[i]["position"]}

print("----------str-----------")
'''
假设有一个初始字符串 `s = "Hello, Python world!"`，进行下面的操作：

 1. 字符串长度计算
 2. 计算字符串中"o"字符的个数
 3. 将字符串转换为大写
 4. 将字符串转换为小写
 5. 查找"Python"在字符串中的位置
 6. 替换字符串中的"world"为"universe"
 7. 检查字符串是否以"Hello"开始
 8. 检查字符串是否以"!"结尾
 9. 以","为分隔符，拆分字符串
 10. 去除字符串首尾的"!"
 11. 字符串反转
 12. 字符串切片，获取"Python"
 13. 将字符串s中的"Hello,"删除
 14. 拼接两个字符串 "Hello," 和 "World!"
 15. 使用f-string合并字符串和数字2021
 16. 找出'a'第一次出现的位置
 17. 找出'e'最后一次出现的位置
 18. 计算字符串中空格的数量
 19. 使用循环遍历字符串中的每个字符
 20. 将字符串转为"列表"形式，每个字符为一个列表元素
 21. 字符串排序（提示：先转换为列表）
 22. 判断字符串是否为数字
 23. 将列表 `['Hello,', 'Python', 'World!']` 使用空格连接为一个字符串
 24. 使用%操作符格式化字符串，将数字100插入到"Number: "后面
 25. 检查字符串是否全部为小写字母
 26. 检查字符串是否全部为大写字母
 27. 将数字列表 `[1, 2, 3]` 转换成字符串，元素之间用`-`连接
 28. 找出字符串中所有的"o"的位置
 29. 替换字符串中的第一个"o"为"O"
 30. 字符串插入操作，向字符串指定位置插入子字符串"amazing "
'''

s = "Hello, Python world!"
#1.字符串长度计算
print(len(s))
#2.计算字符串中"o"字符的个数
print(s.count("o"))
#3.将字符串转换为大写
print(s.upper())
#4.将字符串转换为小写
print(s.lower())
#5.查找"Python"在字符串中的位置
print(s.find("Python"))
#6.替换字符串中的"world"为"universe"
print(s.replace("world","universe"))
#7.检查字符串是否以"Hello"开始
print(s.startswith("Hello"))
#8.检查字符串是否以"!"结尾
print(s.endswith("!"))
#9.以","为分隔符，拆分字符串
print(s.split(","))
#10.去除字符串首尾的"!"
print(s.strip("!"))
#11.字符串反转
print(s[::-1])
#12.字符串切片，获取"Python"
print(s[0:2])
print(s[s.find("Python"):s.find("Python")+len("Python")])
#13.将字符串s中的"Hello,"删除
print(s.replace("Hello,",""))
#14.拼接两个字符串 "Hello," 和 "World!"
print("Hello,"+"World!")
#15.使用f-string合并字符串和数字2021
print(f"Number: {2021}")
#16.找出'a'第一次出现的位置
print(s.find("a"))
#17.找出'e'最后一次出现的位置
print(s.rfind("e"))
#18.计算字符串中空格的数量
print(s.count(" "))
#19.使用循环遍历字符串中的每个字符
for i in s:
    print(i)
#20.将字符串转为"列表"形式，每个字符为一个列表元素
print(list(s))
#21.字符串排序（提示：先转换为列表）
print(sorted(s))
#22.判断字符串是否为数字
print(s.isdigit())
#23.将列表 `['Hello,', 'Python', 'World!']` 使用空格连接为一个字符串
print(" ".join(['Hello,', 'Python', 'World!']))
#24.使用%操作符格式化字符串，将数字100插入到"Number: "后面
print("Number: %d"%100)
#25.检查字符串是否全部为小写字母
print(s.islower())
#26.检查字符串是否全部为大写字母
print(s.isupper())
#27.将数字列表 `[1, 2, 3]` 转换成字符串，元素之间用`-`连接
list=[str(i) for i in range(1,4)]
print("-".join(list))
#28.找出字符串中所有的"o"的位置
print([i for i in range(len(s)) if s[i]=="o"])
#29.替换字符串中的第一个"o"为"O"
print(s.replace("o","O",1))
#30.字符串插入操作，向字符串指定位置插入子字符串"amazing "
print(s[:s.find("Python")]+"amazing "+s[s.find("Python"):])
'''
给定字符串
s = "Python is great!"

完成以下题目
1. 字符串反转: 给定字符串`s = "Python is great!"`，不使用任何内置函数，编写代码以反转字符串。

2. 字符计数: 对于同一个字符串`s`，计算字符 `t'` 在其中出现的次数。

3. 替换字符: 把字符串`s` 中的所有空格替换成下划线 ``。

4. 检查回文: 检查字符串`s2 = "A man, a plan, a canal, Panama!"` 在忽略大小写、标点和空格的情况下是否为回文字符串。

5. 子字符串查找: 在`s` 中查找第一次出现子字符串 `is"` 的位置。

6. 字符串插入: 在`s` 中第一个 `t'` 字符之后插入子字符串`"_inserted"`。

7. 部分替换: 替换`s` 中第一次出现的 `great"` 为 `awesome"`。

8. 切片与拼接: 将`s` 切分为两部分，其中第一部分包含前半部分的字符，第二部分包含后半部分的字符，然后将这两部分以相反顺序拼接起来。

9. 创建字符串列表: 使用列表生成式，根据字符串`s` 创建一个列表，其中包含`s` 的每个单词的首字母大写形式。

10. 字符替换加密: 编写一个函数`encrypt`，使用字典 `a: m, b: n, ... z: l}` 的对应规则加密字符串`s3 = "encryption"`。
'''
s="Python is great!"
#1.字符串反转: 给定字符串`s = "Python is great!"`，不使用任何内置函数，编写代码以反转字符串。
s1=""
for i in range(len(s)-1,-1,-1):
    s1+=s[i]
print(s1)
#2.字符计数: 对于同一个字符串`s`，计算字符 `t'` 在其中出现的次数。
t="t"
count=0
for i in range(len(s)):
    if s[i]==t:
        count+=1
print(count)
#3.替换字符: 把字符串`s` 中的所有空格替换成下划线 ``。
print(s.replace(" ","_"))
#4.检查回文: 检查字符串`s2 = "A man, a plan, a canal, Panama!"` 在忽略大小写、标点和空格的情况下是否为回文字符串。
s2="A man, a plan, a canal, Panama!"
s2=s2.lower()
s2=s2.replace(" ","")
s2=s2.replace(",","")
s2=s2.replace("!","")
print("s2:",s2)
if s2==s2[::-1]:
    print("是回文")
else:
    print("不是回文")
#5. 子字符串查找: 在`s` 中查找第一次出现子字符串 `is"` 的位置。
print(s.find("is"))
#6. 字符串插入: 在`s` 中第一个 `t'` 字符之后插入子字符串`"_inserted"`。
print(s[:s.find("t")+1]+"_inserted"+s[s.find("t")+1:])
#7. 部分替换: 替换`s` 中第一次出现的 `great"` 为 `awesome"`。
print(s.replace("great","awesome"))
#8. 切片与拼接: 将`s` 切分为两部分，其中第一部分包含前半部分的字符，第二部分包含后半部分的字符，然后将这两部分以相反顺序拼接起来。
print(s[len(s)//2:]+s[:len(s)//2])
#9. 创建字符串列表: 使用列表生成式，根据字符串`s` 创建一个列表，其中包含`s` 的每个单词的首字母大写形式。
list=[s[i].upper() for i in range(len(s))]
print(list)
#10. 字符替换加密: 编写一个函数`encrypt`，使用字典 `a: m, b: n, ... z: l}` 的对应规则加密字符串`s3 = "encryption"`。
def encrypt(s):
    dic={"a":"m","b":"n","c":"o","d":"p","e":"q","f":"r","g":"s","h":"t","i":"u","j":"v","k":"w","l":"x","m":"y","n":"z"}
    s1=""
    for i in range(len(s)):
        if s[i] in dic:
            s1+=dic[s[i]]
        else:
            s1+=s[i]
    return s1
s3="encryption"
print(encrypt(s3))


